home *** CD-ROM | disk | FTP | other *** search
/ Floppyshop 2 / Floppyshop - 2.zip / Floppyshop - 2.iso / art&graf.ix / art-4542 / rshade30 / gray22.s < prev    next >
Text File  |  1993-09-06  |  17KB  |  478 lines
  1. ;From gatech!wrdis01!mips!spool.mu.edu!cs.umn.edu!msi.umn.edu!noc.MR.NET!ns!ns!logajan Mon May 20 13:45:34 EDT 1991
  2. ;Article: 39871 of comp.sys.atari.st
  3. ;Path: gatech!wrdis01!mips!spool.mu.edu!cs.umn.edu!msi.umn.edu!noc.MR.NET!ns!ns!logajan
  4. ;From: logajan@ns.network.com (John Logajan)
  5. ;Newsgroups: comp.sys.atari.st
  6. ;Subject: Display 22 levels of gray on color mon.
  7. ;Message-ID: <1991May19.210150.7671@ns.network.com>
  8. ;Date: 19 May 91 21:01:50 GMT
  9. ;Sender: news@ns.network.com
  10. ;Organization: Network Systems Corporation
  11. ;Lines: 436
  12. ;Posted: Sun May 19 16:01:50 1991
  13. ;Originator: logajan@ns
  14. ;Nntp-Posting-Host: ns
  15. ;Sender: kilian
  16. ;Status: OR
  17. ;
  18. ;
  19. ; gray22 -- original code by John Logajan 5-19-91, PUBLIC DOMAIN.
  20. ;                            logajan@ns.network.com
  21. ;
  22. ; This subroutine is called by the ATARI ST COLOR user to go into
  23. ; 22 level grayscale display mode (dithered flicker.)  Any keys pressed
  24. ; from the keyboard will return control back to the user's calling program.
  25. ; Keys pressed will not be disturbed and will be available for inspection
  26. ; by normal TOS routines.  This routine uses 64k just below the normal
  27. ; screen RAM area.
  28. ;
  29. ; This will display a 320x200 minimum window in 22 level grayscale.
  30. ; You can have arbitrarily large virtual displays.  Scrolling the
  31. ; window across the virtual image is accomplished merely by calling this
  32. ; program with a new starting (upper left corner) address.
  33. ;
  34. ; The virtual image must be in the form of one byte per pixel.  Legal
  35. ; intensity values in each byte range from 0 to 21 (decimal.)  The image
  36. ; is organized as left to right and top to bottom.
  37. ;
  38. ; The call to gray22 must include:
  39. ;
  40. ; A0 set to the window starting point (upper left corner) in the image.
  41. ; D0 set to the length of the virtual image horizontal line (bytes).
  42. ;    D0 should never change unless the virtual image size changes.
  43. ;    D0 is *not* 320 unless the virtual image size is the same as the
  44. ;    window size (the window size *is* always 320.)
  45. ;
  46. ; There are three subroutines below.  One initializes everything, one
  47. ; restores everything on exit, one displays the window and also has
  48. ; an entry point for simply going back into display mode without
  49. ; changing the current screen contents (useful for quick returns
  50. ; from invalid keypressed keys.)
  51. ; 
  52. ; jsr grayinit -- should be called once to go into low resolution mode.
  53. ;                 Calling grayinit twice or more without intervening
  54. ;                 calls to grayexit will cause original modes to be
  55. ;                 forgotten.
  56. ;
  57. ; jsr grayexit -- should be called once on exit to restore previous modes.
  58. ;                 Don't call grayexit if you haven't yet called grayinit.
  59. ;
  60. ; jsr gray22   -- should be called with A0 and D0 set, to update display.
  61. ;                 Don't call gray22 if you haven't yet called grayinit.
  62. ;
  63. ; jsr grayshow -- should be called to bypass update and continue previous
  64. ;                 display.  gray22 automatically executes grayshow.
  65. ;                 Don't call grayshow if you haven't yet called grayinit
  66. ;                 and gray22 at least once.
  67.  
  68.           text
  69.           even
  70.  
  71.           globl grayinit, grayexit, gray22, grayshow
  72.  
  73. ;
  74. ; Here is gray22, be sure to have called grayinit before calling this.
  75. ; Also be sure to set A0 and D0 before each gray22 call.
  76. ;
  77. gray22:   movem.l   d3-d7/a2-a6,regsave
  78.  
  79.           move.l a0,corner     ; save the starting corner
  80.  
  81.           sub.l #320,d0        ; compute and save the window factor
  82.           move.l d0,wrapit
  83. ;
  84. ; We get 22 shades of gray by flipping between three screens each
  85. ; with different combinations of eight shades of gray (the atari
  86. ; hardware limit.)  The table below shows the general theory:
  87. ; 
  88. ; Screen           Screen           Screen
  89. ; 0 1 2  Shade     0 1 2  Shade     0 1 2  Shade
  90. ;
  91. ; 7 7 7   21       4 4 5   13       2 2 1   5
  92. ; 7 7 6   20       4 4 4   12       1 1 2   4
  93. ; 6 6 7   19       4 4 3   11       1 1 1   3
  94. ; 6 6 6   18       3 3 4   10       1 1 0   2
  95. ; 6 6 5   17       3 3 3    9       0 0 1   1
  96. ; 5 5 6   16       3 3 2    8       0 0 0   0
  97. ; 5 5 5   15       2 2 3    7
  98. ; 5 5 4   14       2 2 2    6
  99. ;
  100. ; In addition, to keep flicker to a minimum, we phase dither each intensity
  101. ; with a three horizontal by three vertical pixel intensity interlace.
  102. ; For instance, a block of intensity-18 pixels would be displayed as such:
  103. ;
  104. ; ... First Screenful ...   ... Second Screenful ...   ...Third Screenful...
  105. ; ... 6 6 7 6 6 7 6 6 ...   ... 6 7 6 6 7 6 6 7  ...   ... 7 6 6 7 6 6 7 ...
  106. ; ... 6 7 6 6 7 6 6 7 ...   ... 7 6 6 7 6 6 7 6  ...   ... 6 6 7 6 6 7 6 ...
  107. ; ... 7 6 6 7 6 6 7 6 ...   ... 6 6 7 6 6 7 6 6  ...   ... 6 7 6 6 7 6 6 ...
  108. ; ...      etc        ...   ...       etc        ...   ...       etc     ...
  109. ;
  110.  
  111. ;
  112. ; Do first screen full.
  113. ;
  114.           move.w #-1,-(sp)     ; keep resolution
  115.           move.l phy0,-(sp)    ; switch to phys addr screen #0
  116.           move.l phy0,-(sp)    ; switch to logical addr screen #0
  117.           move.w #5,-(sp)      ; setscreen
  118.           trap #14
  119.           add.l #12,sp
  120.  
  121.           move.l #gtable,a5   ; conversion table base address
  122.           move.l corner,a2    ; get start point
  123.           move.l phy0,a1      ; get screen start address
  124. ;
  125. ; First of three grouped horizontal lines.
  126. ;
  127.           move.w #66,d7       ; 200 lines
  128. b0r1:     move.l #templine,a3 ; where we build a temporary line
  129.           move.w #106,d6      ; 320 bits per line
  130. b0r2:     clr.l d0
  131.           move.b (a2)+,d0 
  132.           move.b (a5,d0),d0   ; dither pixel horz 0 -- line 0
  133.           move.b d0,(a3)+
  134.           clr.l d0
  135.           move.b (a2)+,d0
  136.           move.b 22(a5,d0),d0 ; dither pixel horz 1 -- line 0
  137.           move.b d0,(a3)+
  138.           clr.l d0
  139.           move.b (a2)+,d0
  140.           move.b 44(a5,d0),d0 ; dither pixel horz 2 -- line 0
  141.           move.b d0,(a3)+
  142.           dbf d6,b0r2
  143.           add.l wrapit,a2     ; window correction factor
  144.           subq.l #1,a2        ; backup 1 pixel
  145.           jsr repac320
  146. ;
  147. ; Second of three grouped horizontal lines
  148. ;
  149.           move.l #templine,a3
  150.           move.w #106,d6
  151. b0r3:     clr.l d0
  152.           move.b (a2)+,d0
  153.           move.b 22(a5,d0),d0 ; dither pixel horz 0 -- line 1       
  154.           move.b d0,(a3)+
  155.           clr.l d0
  156.           move.b (a2)+,d0
  157.           move.b 44(a5,d0),d0 ; dither pixel horz 1 -- line 1         
  158.           move.b d0,(a3)+
  159.           clr.l d0
  160.           move.b (a2)+,d0
  161.           move.b (a5,d0),d0   ; dither pixel horz 2 -- line 1
  162.           move.b d0,(a3)+
  163.           dbf d6,b0r3
  164.           add.l wrapit,a2     ; window correction factor
  165.           subq.l #1,a2        ; backup 1 pixel
  166.           jsr repac320
  167. ;
  168. ; Third of three grouped horizontal lines.
  169. ;
  170.           move.l #templine,a3
  171.           move.w #106,d6
  172. b0r4:     clr.l d0
  173.           move.b (a2)+,d0
  174.           move.b 44(a5,d0),d0 ; dither pixel horz 0 -- line 2
  175.           move.b d0,(a3)+
  176.           clr.l d0
  177.           move.b (a2)+,d0
  178.           move.b (a5,d0),d0   ; dither pixel horz 1 -- line 2
  179.           move.b d0,(a3)+
  180.           clr.l d0
  181.           move.b (a2)+,d0
  182.           move.b 22(a5,d0),d0 ; dither pixel horz 2 -- line 2
  183.           move.b d0,(a3)+
  184.           dbf d6,b0r4
  185.           add.l wrapit,a2     ; window correction factor
  186.           subq.l #1,a2        ; backup 1 pixel
  187.           jsr repac320        ; paint a screen line
  188.           dbf d7,b0r1         ; go do next three screen lines
  189. ;
  190. ; Do second screen.
  191. ;
  192.           move.l corner,a2    ; get start point
  193.           move.l phy1,a1      ; get screen start address
  194.           move.w #66,d7       ; 200 lines
  195. b1r1:     move.l #templine,a3 ; where we build a temporary line
  196.           move.w #106,d6      ; 320 bits per line
  197. b1r2:     clr.l d0
  198.           move.b (a2)+,d0
  199.           move.b 22(a5,d0),d0          
  200.           move.b d0,(a3)+
  201.           clr.l d0
  202.           move.b (a2)+,d0
  203.           move.b 44(a5,d0),d0          
  204.           move.b d0,(a3)+
  205.           clr.l d0
  206.           move.b (a2)+,d0
  207.           move.b (a5,d0),d0          
  208.           move.b d0,(a3)+
  209.           dbf d6,b1r2
  210.           add.l wrapit,a2     ; window correction factor
  211.           subq.l #1,a2        ; backup 1 pixel
  212.           jsr repac320
  213.           move.l #templine,a3
  214.           move.w #106,d6
  215. b1r3:     clr.l d0
  216.           move.b (a2)+,d0
  217.           move.b 44(a5,d0),d0          
  218.           move.b d0,(a3)+
  219.           clr.l d0
  220.           move.b (a2)+,d0
  221.           move.b (a5,d0),d0          
  222.           move.b d0,(a3)+
  223.           clr.l d0
  224.           move.b (a2)+,d0
  225.           move.b 22(a5,d0),d0          
  226.           move.b d0,(a3)+
  227.           dbf d6,b1r3
  228.           add.l wrapit,a2     ; window correction factor
  229.           subq.l #1,a2        ; backup 1 pixel
  230.           jsr repac320
  231.           move.l #templine,a3
  232.           move.w #106,d6
  233. b1r4:     clr.l d0
  234.           move.b (a2)+,d0
  235.           move.b (a5,d0),d0          
  236.           move.b d0,(a3)+
  237.           clr.l d0
  238.           move.b (a2)+,d0
  239.           move.b 22(a5,d0),d0          
  240.           move.b d0,(a3)+
  241.           clr.l d0
  242.           move.b (a2)+,d0
  243.           move.b 44(a5,d0),d0          
  244.           move.b d0,(a3)+
  245.           dbf d6,b1r4
  246.           add.l wrapit,a2     ; window correction factor
  247.           subq.l #1,a2        ; backup 1 pixel
  248.           jsr repac320        ; paint a screen line
  249.           dbf d7,b1r1         ; go do next three screen lines
  250. ;
  251. ; Do third screen
  252. ;
  253.           move.l corner,a2    ; get start point
  254.           move.l phy2,a1      ; get screen start address
  255.           move.w #66,d7       ; 200 lines
  256. b2r1:     move.l #templine,a3 ; where we build a temporary line
  257.           move.w #106,d6      ; 320 bits per line
  258. b2r2:     clr.l d0
  259.           move.b (a2)+,d0
  260.           move.b 44(a5,d0),d0          
  261.           move.b d0,(a3)+
  262.           clr.l d0
  263.           move.b (a2)+,d0
  264.           move.b (a5,d0),d0          
  265.           move.b d0,(a3)+
  266.           clr.l d0
  267.           move.b (a2)+,d0
  268.           move.b 22(a5,d0),d0          
  269.           move.b d0,(a3)+
  270.           dbf d6,b2r2
  271.           add.l wrapit,a2     ; window correction factor
  272.           subq.l #1,a2        ; backup 1 pixel
  273.           jsr repac320
  274.           move.l #templine,a3
  275.           move.w #106,d6
  276. b2r3:     clr.l d0
  277.           move.b (a2)+,d0
  278.           move.b (a5,d0),d0          
  279.           move.b d0,(a3)+
  280.           clr.l d0
  281.           move.b (a2)+,d0
  282.           move.b 22(a5,d0),d0          
  283.           move.b d0,(a3)+
  284.           clr.l d0
  285.           move.b (a2)+,d0
  286.           move.b 44(a5,d0),d0          
  287.           move.b d0,(a3)+
  288.           dbf d6,b2r3
  289.           add.l wrapit,a2     ; window correction factor
  290.           subq.l #1,a2        ; backup 1 pixel
  291.           jsr repac320
  292.           move.l #templine,a3
  293.           move.w #106,d6
  294. b2r4:     clr.l d0
  295.           move.b (a2)+,d0
  296.           move.b 22(a5,d0),d0          
  297.           move.b d0,(a3)+
  298.           clr.l d0
  299.           move.b (a2)+,d0
  300.           move.b 44(a5,d0),d0          
  301.           move.b d0,(a3)+
  302.           clr.l d0
  303.           move.b (a2)+,d0
  304.           move.b (a5,d0),d0          
  305.           move.b d0,(a3)+
  306.           dbf d6,b2r4
  307.           add.l wrapit,a2     ; window correction factor
  308.           subq.l #1,a2        ; backup 1 pixel
  309.           jsr repac320        ; paint a screen line
  310.           dbf d7,b2r1         ; go do next three screen lines, else show
  311.  
  312.           bra graysh1
  313. ;
  314. ; This section of the code continuously flips through the three video
  315. ; screens to generate the flicker grayscale effect.  Any keypress will
  316. ; cause a subroutine exit back to the user calling program.
  317. ;
  318. ; You can call this directly if you want to avoid the delay of updating
  319. ; a screen that doesn't need to be updated.  However, it makes no sense
  320. ; to call this if you haven't already called grayinit and gray22 at least
  321. ; once prior.
  322. ; 
  323. grayshow: movem.l   d3-d7/a2-a6,regsave
  324.  
  325. graysh1:  move.w #37,-(sp)    ; wait for vsync
  326.           trap #14
  327.           addq.l #2,sp
  328.  
  329.           move.w #-1,-(sp)     ; keep resolution
  330.           move.l phy1,-(sp)    ; switch phys addr to screen #1
  331.           move.l #-1,-(sp)     ; keep logical addr
  332.           move.w #5,-(sp)      ; setscreen
  333.           trap #14
  334.           add.l #12,sp
  335.  
  336.           move.w #37,-(sp)    ; wait for vsync
  337.           trap #14
  338.           addq.l #2,sp
  339.  
  340.           move.w #-1,-(sp)     ; keep res
  341.           move.l phy2,-(sp)    ; switch phys addr to screen #2
  342.           move.l #-1,-(sp)     ; keep logical addr
  343.           move.w #5,-(sp)      ; setscreen
  344.           trap #14
  345.           add.l #12,sp
  346.  
  347.           move.w #37,-(sp)    ; wait for vsync
  348.           trap #14
  349.           addq.l #2,sp
  350.  
  351.           move.w #-1,-(sp)     ; keep res
  352.           move.l phy0,-(sp)    ; switch phys addr to screen #1
  353.           move.l #-1,-(sp)     ; keep logical addr
  354.           move.w #5,-(sp)      ; setscreen
  355.           trap #14
  356.           add.l #12,sp
  357.  
  358.           move.w #$0b,-(sp)   ; check for keypress
  359.           trap #1
  360.           addq.l #2,sp
  361.           tst.w d0
  362.           beq grayshow        ; keep flipping screens if no keypress
  363.  
  364.           movem.l   regsave,d3-d7/a2-a6
  365.           rts                 ; else exit back to calling user program
  366. ;
  367. ; Subroutine to distribute one line's worth of color register numbers
  368. ; into goofy Atari video ram format. (This is five times faster than
  369. ; using the Atari Line-A Put-Pixel A001 routine.)
  370. ;
  371. repac320: move.w #19,d6       ; do 20 groups of 16 pixels (320)
  372.           move.l #templine,a0 ; point to temp line of color registers. 
  373. repack16: move.w #15,d5       ; do 16 pixels
  374. repack:   move.b (a0)+,d0     ; get each color register number.
  375.           roxr.b #1,d0
  376.           roxl.w #1,d1        ; pick off lsb
  377.           roxr.b #1,d0
  378.           roxl.w #1,d2        ; pick off lsb+1
  379.           roxr.b #1,d0
  380.           roxl.w #1,d3        ; pick off lsb+2
  381.           dbf d5,repack
  382.           move.w d1,(a1)+     ; 16 pixel LSB's (a1 points to video ram)
  383.           move.w d2,(a1)+
  384.           move.w d3,(a1)+
  385.           clr.w (a1)+         ; 16 pixel MSB's  (MSB always zero)
  386.           dbf d6,repack16
  387.           rts                 ; return to calling program
  388. ;
  389. ; This routine allocates an additional 64k bytes for two more screens,
  390. ; saves the original palette and resolution for later restore.  And
  391. ; switches to low resolution and installs the grayscale palette.
  392. ;
  393. grayinit: movem.l   d3-d7/a2-a6,regsave
  394.  
  395.           move.w #2,-(sp)     ; get screen physical base address
  396.           trap #14
  397.           addq.l #2,sp
  398.           move.l d0,phy0      ; save address of screen #0
  399.           sub.l #32768,d0 
  400.           move.l d0,phy1      ; save address of screen #1
  401.           sub.l #32768,d0
  402.           move.l d0,phy2      ; save address of screen #2
  403.  
  404.           move.l #oldpal,a5   ; save each color number of the old palette
  405.           move.w #0,d5
  406.           move.w #15,d6
  407. gncolor:  move.w #-1,-(sp)
  408.           move.w d5,-(sp)     ; color number
  409.           move.w #7,-(sp)
  410.           trap #14
  411.           addq.l #6,sp
  412.           move.w d0,(a5)+     ; previous color saved
  413.           addq.w #1,d5
  414.           dbf d6,gncolor
  415.  
  416.           move.w #4,-(sp)     ; get and save original resolution
  417.           trap #14
  418.           addq.l #2,sp
  419.           move.w d0,oldres
  420.  
  421.           move.w #0,-(sp)     ; switch to low res
  422.           move.l #-1,-(sp)    ; keep phys addr
  423.           move.l #-1,-(sp)    ; keep logical addr
  424.           move.w #5,-(sp)     ; setscreen
  425.           trap #14
  426.           add.l #12,sp
  427.  
  428.           move.l #newpal,-(sp) ; install new palette
  429.           move.w #6,-(sp)
  430.           trap #14
  431.           addq.l #6,sp
  432.  
  433.           movem.l   regsave,d3-d7/a2-a6
  434.           rts
  435. ;
  436. ;  This routine restores original resolution, screen, and palette
  437. ;
  438. grayexit: move.w oldres,-(sp) ; old resolution
  439.           move.l phy0,-(sp)   ; old phys addr
  440.           move.l phy0,-(sp)   ; old logical addr
  441.           move.w #5,-(sp)     ; setscreen
  442.           trap #14
  443.           add.l #12,sp
  444.  
  445.           move.l #oldpal,-(sp) ; install old palette
  446.           move.w #6,-(sp)
  447.           trap #14
  448.           addq.l #6,sp
  449.           rts
  450. ;
  451. ; Variable and storage area
  452. ;
  453.           data
  454.           even
  455.  
  456. newpal:   dc.w 0,$111,$222,$333,$444,$555,$666,$777,0,0,0,0,0,0,0,0
  457. oldpal:   dc.w 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  458. gtable:   dc.b 0,0,1,1,1,2,2,2,3,3,3,4,4,4,5,5,5,6,6,6,7,7
  459.           dc.b 0,0,1,1,1,2,2,2,3,3,3,4,4,4,5,5,5,6,6,6,7,7
  460.           dc.b 0,1,0,1,2,1,2,3,2,3,4,3,4,5,4,5,6,5,6,7,6,7
  461. phy0:     dc.l 0
  462. phy1:     dc.l 0
  463. phy2:     dc.l 0
  464. oldres:   dc.l 0
  465. wrapit:   dc.l 0
  466. corner:   dc.l 0
  467.  
  468.           bss
  469.           even
  470.  
  471. regsave:  ds.l 16
  472. templine: ds.l 81
  473.  
  474. ;-- 
  475. ;- John Logajan @ Network Systems; 7600 Boone Ave; Brooklyn Park, MN 55428
  476. ;- logajan@ns.network.com, 612-424-4888, Fax 612-424-2853
  477.  
  478.